COMMENT ⊗   VALID 00017 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002	purpose and use of this file
C00004 00003	DEFINE RECORDS=[
C00009 00004	XX(MENU,	"MENU",	"gives a list of toplevel instructions")
C00010 00005	XX(RES_WORDS,	"RES",	"gives a list of reserved words")
C00012 00006	XX(RES_HELP,	"RESH",	"gives one line descriptions of the reserved words")
C00019 00007	XX(DISPLAYS,	"DISP",	"describes display commands")
C00021 00008	XX(ELF,		"ELF",	["gives information on the ELF, or PDP-11 interface"])
C00022 00009	XX(VT05,	"VT05",	"describes VT05")
C00023 00010	XX(OPERATIONS,	"OPER",	"shows available operators and functions")
C00033 00011	XX(EXPRESSIONS,	"EXP",	"valid expressions")
C00036 00012	XX(FILE,	"FILE",	"Gives the file management commands")
C00042 00013	XX(ESCAPE_I,	"ESC_I","ESCAPE I command")
C00044 00014	XX(STATEMENTS,	"STATE","classes of statements")
C00057 00015	XX(ERROR,	"ERROR", "talks about how to handle errors")
C00060 00016	XX(SYNTAX,	"SYNTAX","syntax of statements")
C00062 00017	XX(DONE,	"DONE",	"quits help mode")
C00063 ENDMK
C⊗;
COMMENT purpose and use of this file
	This file is used as a source file in the compilation of
	HELP0, and data from this file eventually ends up in
	HELP.NUM,HELP.KEY,HELP.DAT

	If you change this file, execute HELP0.SAI to generate new
	data files for the POINTY program.

	Dont put any more semicolons on this page or the SAIL compiler
	will complain.
							MSM 8/31/79
;
DEFINE RECORDS=[
XX(QUESTION,	"?",	"displays this information")
YY(QUESTION_X)
YY(MENU_X)
YY(UP_X)
YY(DONE_X)
YY(QQUESTION_X)
YY(HELP_X)
YY(BUGS_X)
YY(INFO_X)

XX(BUGS,	"BUGS",["what to do about apparent bugs"])
YY(BUGS_DES_X)
XX(BUGS_DES,NULL,	["	If there appears to be bugs, or something does
	not work the way you think it should, a good source is this helper or
	the AL USERS' MANUAL, which you should be familiar with if
	you are running this program by yourself.
		If either of these sources do not convince you it is not a bug,
	you can log down the error and what you were doing at the time, and
	your cusswords by getting out of the helper and typing these
	things between open and close brace pairs{}.  e.g. {arm refused to move}
	This will be treated as a comment, but will be recorded in a logging
	file.
		When you are done with POINTY, send or mail MSM a message
	saying that there were bugs, and complaints were logged in the
	logging file."])

XX(INFO,	NULL,	["
		Type one of the keywords on the left column.  If you
	don't understand any of this, type HELP"])

XX(HELP,	"HELP",	["help on the use of this helper"])
YY(HELP_DES_X)
XX(HELP_DES,	NULL,	["	This helper is organized as as a directed
	graph with loops, and to each node there corresponds a message.
	Terminal nodes have no keyword associated with them, whereas
	inside nodes do.
		If the message is too long to fit on the screen,
	<formfeed> and <vert tab> may be used to scroll up and down the
	screen the way E does it.  If the message can fit in one screenful
	these will have no effect.
		At any time in the help mode, the following keywords
	are valid:
		a) The list of keywords on the left hand column of the
	screen.
		b) The list of keywords on the left hand column of the
	screen the previous time.
		c) The list of keywords on the keyword stack at the
	bottom of the screen.

		If you type a valid keyword, that keyword will appear
	as the last element of the keyword stack.  Since keywords
	are not repeated on the keyword stack, this means that sometimes
	the keyword stack may be trimmed back.

		If an invalid keyword is typed, it is as if you typed ?
	but the keyword stack will not be cut back.

		Note that you are now in a different mode.  Normal POINTY
	or AL commands will not work until you get out of the helper mode
	by using the DONE command."])

XX(QQUESTION,	"??",	"ideas for other help topics")
YY(QQUESTION_DES_X)

XX(QQUESTION_DES,NULL,	["	If there is a help topic that you think should
	be here that isnt, please send a message to MSM about it, with
	suggestions for the text of the message and at what level it should be
	invoked."])

XX(UP,		"UP",	"goes up a level on the keyword stack")

XX(MENU,	"MENU",	"gives a list of toplevel instructions")
YY(RES_WORDS_X)
YY(RES_HELP_X)
YY(DISPLAYS_X)
YY(ELF_X)
YY(VT05_X)
YY(OPERATIONS_X)
YY(EXPRESSIONS_X)
YY(FILE_X)
YY(ESCAPE_I_X)
YY(STATEMENTS_X)
YY(ERROR_X)
YY(SYNTAX_X)
XX(RES_WORDS,	"RES",	"gives a list of reserved words")
YY(RESERVED_X)
XX(RESERVED,	NULL,	["These are reserved words:
	ABORT	ACOS	AFFIX	ALL	AND	ARRAY	ASIN	ATAN2	AXIS
	BAIL	BEGIN	BY
	CASE	CENTER	CLOSE	COBEGIN	COEND	COMMENT	CONSTRUCT	COS
	DDT	DEFINE	DELETE	DISPLAY	DO	DRIVE	DUMP_VARIABLES
	ECHOOFF	ECHOON	EDIT	EEDIT	END	EQV	EVAL	EVENT
	EXIT	EXP	{FCONSTRUCT}	FOR	FRAME	FUNCTION
	GATHER	GRAPH	HELP	IF	INT	INTO	INV
	LOAD_VARIABLES
	MAX	MIN	MOD	MOVE	MOVEX	MOVEY	MOVEZ
	NODISPLAY	NOUPDATE	ON	OPEN	OR	ORIENT
	PARK	POS	PRINT	PROCEDURE	PROMPT	QBAIL	QREAD
	READ	READWRIST	REDEFINE	REDISPLAY	REFERENCE
	REL	RENAME	RESETSTATUS	RETURN	ROT
	SAVECOREIMAGE
	SCALAR	SETBASE	SETSTATUS	SETSTIFF	SHOW	SIGNAL
	SIN	SQRT	STOP	STOPMESSAGE	SUBTREE
	TAN	TO	TRANS	UNFIX	UNIT	UPDATE
	VALUE	VECTOR	VTT05_OFF	VT05_ON	WAIT	
	WHILE	WRIST	WRITE	WRT
	XCOORD	XOR	YCOORD	XCOORD"])
XX(RES_HELP,	"RESH",	"gives one line descriptions of the reserved words")
YY(RES_HELP_DES_X)

XX(RES_HELP_DES,NULL,	["ABORT	stops the current action and throws you into DDT
	ACOS	arc cosine
	AFFIX	affix statement
	ALL	reserved word used with WRITE, DELETE, etc
	ARRAY	used for array declarations
	ASIN	arc sine
	ATAN2	arctangent taking two arguments
	BAIL	calls the SAIL debugger: not available in all versions
	BEGIN	denotes beginning of a block
	BY	reserved word used in MOVE, OPEN, CLOSE, AFFIX
	CASE	control statement
	CLOSE	close the hand
	COBEGIN	parallel control
	COEND	indicates end of COBEGIN block
	COMMENT	comment statment: non executabl statement
	CONSTRUCT	makes a trans out of three vectors
	COS	cosine function
	DDT	throws you into DDT: you better know what you are doing
	DEFINE	macro definitions
	DELETE	deletes variables
	DISPLAY displays appropriate data types
	DO	loop
	DUMP_VARIABLES	saves all the values of variables in a disk file
	DRIVE	moves individual joints
	ECHOOFF suppresses printing of input file: normal mode for QREAD
	ECHOON	prints out input file: normal mode for READ
	EDIT	edits values of variable or macro
	EEDIT	swaps to E for editing
	END	ends a block
	≡ EQV	equivalence
	EVAL	direct evaluation
	EVENT	event declaration
	EXIT	exits from POINTY, can resume by typing CONT
	EXP	exponentiation
	FCONSTRUCT	constructs frame from 3 transes
	FOR	loop iteration
	FRAME	frame definition or declaration
	FUNCTION	no longer valid
	GATHER	to gather data
	HELP	gets the help moe
	IF	if control statement
	INT	integer part of a scalar expression
	INTO	used for COPY/MERGE
	INV	inverse trans
	LOAD_VARIABLES	reads in the variables from a dump file
	LOG	logarithm
	MAX	maximum of two expressions
	MIN	minimum of two scalar expressions
	MOD	modulus (remainder)
	MOVE	general motion statement
	MOVEX	motion in the X direction
	MOVEY	motion in the Y direction
	MOVEZ	motion in the Z direction
	NODISPLAY	shuts off the display
	NOPUDATE	does not update the display
	ON	condition monitor or used in motion statement
	OPEN	pertains to the hand opening
	∨ OR	boolean OR operator
	ORIENT	the rotation part of a frame or trans
	PARK	parks the arm
	POS	vector part of a frame or trans
	PRINT	prints arguments on the VT05
	PROCEDURE	procedure declaration
	PROMPT	waits for user to type P at the VT05
	QBAIL	like BAIL, but takes input from QUERY.TXT on current PPN
	QREAD	like READ, but does not print on terminal what is being read
	READ	reads in the appropriate file
	READWRIST	reads the wrist
	REDEFINE	changes definition of a macro
	REDISPLAY	gets the normal table mode
	REFERENCE	type of argument used for parameter specification
	REL	relative positons
	RENAME	change the name of a variable
	RESETSTATUS	change the value of compiler parameters to 0
	RETURN	gets out of a procedure
	ROT	the rotation operator or declaration
	SAVECOREIMAGE	saves the state of the 10 and 11
	SCALAR	used for declarations
	SETBASE	assumes there is zero force on the wrist
	SETSTATUS	changes the values of compiler parameters
	SETSTIFF	sets wrist stiffness matrix
	SHOW	displays values of a list of variables
	SIGNAL	signals the event
	SIN	the sine function
	SQRT	the square root function
	STOPMESSAGE	message received from interjob mail system is ended
	TAN	tangent function
	TO	used in AFFIX,MOVE,OPEN
	TRANS	used for declaration and to make trans data type
	UNFIX	the UNFIX statement
	UNIT	computes a unit vector
	UPDATE	updates the display
	VALUE	used for declaration of procedure parameters
	VECTOR	constructing data type or declaring vectors
	VT05_OFF turns off updating of VT05
	VT05_ON	turns on updating of VT05 (default)
	WAIT	used with event
	WHILE	loop
	WRIST	reads the force wrist readings
	WRITE	writes AL declarations into a file
	WRT	operator
	XCOORD	refers to x-coordinate of a vector,trans or frame
	XOR	does exclusive or
	YCOORD	refers to y-coordinate of a vector,trans or frame
	ZCOORD	refers to z-coordinate of a vector,trans or frame"])
XX(DISPLAYS,	"DISP",	"describes display commands")
YY(DISPLAY_INFO_X)
XX(DISPLAY_INFO,NULL,	["The display commands relate to the display on the user
	and there are several modes of display: the table display mode (the
	display you get on starting up), the type display mode, the nodisplay
	mode, and the variable display mode.
	    NODISPLAY takes no arguments, shuts off displays
	    REDISPLAY gets you back into the table display mode
	    DISPLAY <type> displays all the variables of type <type>,
		where <type> may be SCALAR,VECTOR,ROT,TRANS,FRAME,
		EVENT,MACRO,PROCEDURE
	    UPDATE forces immediate update of the display
	    NOUPDATE prevents updating of the display
	    SHOW <variable list> displays the variables in the <variable list>"])
XX(ELF,		"ELF",	["gives information on the ELF, or PDP-11 interface"])
YY(ELF_INFO_X)
XX(ELF_INFO,	NULL,	["	The ELF is the name given to the interface
	between the PDP-10 and PDP-11.  Before POINTY can be run successfully,
	the runtime system must be loaded and started on the ELF, by means
	of the DO POINTY[PNT,HE] command.  This will start the program on
	the PDP-11, but sometimes there may be errors that cause the
	program to stop executing and enter DDT.  When that happens,
	try to find out what is wrong, and get it to continue executing,
	or the interactive part on the PDP-10 will not work."])
XX(VT05,	"VT05",	"describes VT05")
YY(VT05_INFO_X)
XX(VT05_INFO,	NULL,	["The VT05 is a terminal directly connected to the PDP-11.
	It prints out the status of the arm joints and limits.
	VT05_ON prints out the joint angles continuously;
	VT05_OFF shuts off the printing of joint angles on VT05"])
XX(OPERATIONS,	"OPER",	"shows available operators and functions")
YY(LOGICALOPS_X)
YY(ARITHOPS_X)
YY(FUNCTIONS_X)
YY(RELATIONALOPS_X)

XX(LOGICALOPS,	"LOGIC","gives a list of logical operators")
YY(EQV_X)
YY(OR_X)
YY(AND_X)
YY(XOR_X)
YY(NOT_X)
XX(RELATIONALOPS,"RELAT","list of relational operators")
YY(RELOPS_X)
XX(ARITHOPS,	"ARITH","gives a list of arithmetic operators")
YY(PLUS_X)
YY(MINUS_X)
YY(TIMES_X)
YY(DIVISION_X)
YY(DIV_X)
YY(DOT_X)
YY(SCALAROPS_X)
YY(VECTOROPS_X)
YY(ROTOPS_X)
YY(TRANSOPS_X)
YY(EXTRACTIONOPS_X)
YY(IMPLICITOPS_X)
XX(FUNCTIONS,	"FUNCT","gives a list of available functions")
YY(TRANSD_X)
YY(TRIG_X)
YY(SQRT_X)
XX(SCALAROPS,	"SCOPS","list of operations that give a scalar result")
YY(SC_DES_X)
XX(VECTOROPS,	"VTOPS","list of operations giving vector result")
XX(ROTOPS,	"RTOPS","list of operations giving rot result")
XX(TRANSOPS,	"TROPS","list of operations giving trans/frame result")
XX(EXTRACTIONOPS,"EXOPS","extraction functions")
XX(IMPLICITOPS,	"IMPOPS","implicit data types")

XX(EQV,		NULL,	"≡    EQV	equivalence ")
XX(OR,		NULL,	"∨    OR	logical OR")
XX(XOR,		NULL, "⊗    XOR	exclusive OR")
XX(AND,		NULL, "∧    AND	logical AND")
XX(RELOPS,	NULL, "≤ < ≠ = > ≥	relational operators")
XX(PLUS,	NULL,	"+		addition")
XX(MINUS,	NULL,	"-		negation or difference")
XX(DOT,		NULL,	".		vector dot product")
XX(TIMES,	NULL,	"*		product")
XX(DIVISION,	NULL, "/		division")
XX(MAX,		NULL,	"MAX		maximum of two operands")
XX(MIN,		NULL,	"MIN		minimum of two operands")
XX(DIV,		NULL,	"DIV		integer division quotient")
XX(MOD,		NULL, "MOD		integer division remainder")
XX(REL,		NULL,	"REL		vector or trans relative to frame")
XX(WRT,		NULL,	"WRT		vector or trans with respect to frame")
XX(BACKARROW,	NULL,	"→		relative transform between two frames or transes")
XX(EXPON,	NULL,	"↑		expoenentiation")
XX(NOT,		NULL,	"¬		logical not")
XX(ORIENT,	NULL,	"ORIENT		rotation part of a frame or trans")
XX(UNIT,	NULL,	"UNIT		conversion of a vector to unit vector")
XX(AXIS,	NULL,	"AXIS		the axis of rotation")
XX(INV,		NULL,	"INV		inverse of a rot or trans")
XX(INT,		NULL,	"INT		integer part of a scalar")
XX(CONSTRUCT,	NULL,	"CONSTRUCT	constructs a frame from 3 vectors")
XX(SQRT,	NULL,	"SQRT		square root function")
XX(TRIG,	NULL,	"SIN COS TAN ASIN ACOS ATAN2	relevant trig functions")
XX(TRANSD,	NULL,	"LOG EXP	relevant transcendental functions")
XX(DOWN,	NULL,	"↓		downward orientation")
XX(STATION,	NULL,	"$		station orientation")
XX(ALPHA,	NULL,	"α		bpark orientation(???)")
XX(EVAL,	NULL,	["{EVAL		evaluate immediate}"])
XX(MAG,		NULL, ["|..|		magnitude of scalar or vector, or angle of rotation"])
XX(PAREN,	NULL,	["( .. )	implicit data type declaration"])
XX(DECL,	NULL,	"FRAME VECTOR TRANS ROT	make the appropriate data type")
XX(COORD,	NULL,	"XCOORD YCOORD ZCOORD    the relevant component of the vector or trans")

XX(SC_DES,	NULL,	["The following operations return a scalar value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	s + s		scalar addition
	s - s		scalar subtraction
	s * s		scalar multiplication
	s / s		scalar division
	s ↑ s		scalar raised to a scalar power
	s MAX s		maximum
	s MIN s		minimum
	INT(s)		integer part of s
	s DIV s		integer quotient after applying INT to each argument
	s MOD s		integer remainder after applying INT to each argument
	v . v		dot product of two vectors
	|s|		absolute value of a scalar
	|v|		magnitude of vector (vector norm)
	|r|		extracts angle of rotation
	INSCALAR	reads a scalar from the console

	Scalar functions
	SQRT(s)		square root
	SIN(s)		sine (all trigonometric functions are in degrees)
	COS(s)		cosine
	TAN(s)		tangent
	ASIN(s)		arc-sine
	ACOS(s)		arc-cosine
	ATAN2(s,s)	arc-tangent of s/s
	LOG(s)		natural logarithm
	EXP(s)		e raised to the s power

	s <rel> s	returns true if relation is satisfied, else false
			possible relations are: <,≤,=,≥,>,≠
	s ∧ s		logical and
	s ∨ s		logical or
	s ⊗ s		logical exclusive or
	s ≡ s		logical equivalence
	  ¬ s		logical not
	QUERY	reads a boolean from the console"])


XX(VEC_DES,	NULL,	["The following operations return a scalar value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	VECTOR(s,s,s)	construct vector given (x,y,z) components
	s * v		dilation of a vector
	v / s		contraction of a vector
	v + v		vector addition
	v - v		vector subtraction
	v * v		vector cross product
	r * v		rotation of a vector
	t * v		transformation of a vector
	f * v		transformation of a vector - shorthand for (station → f) * v
	v WRT f		vector in station coordinates pointing
			the same way as v points in f's coordinate
			system.  v WRT f ≡ ORIENT(f)*v ≡ (f*v) - POS(f)
	UNIT(v)		vector of unit length with same direction as v
	POS(f)		vector position of frame or trans
	AXIS(r)		axis of rotation"])

XX(RT_DES,	NULL,	["The following operations return a scalar value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	ROT(v,s)	constructs rotation of s degrees about v
	ORIENT(f)	orientation of a frame or trans
	r * r		composition of two rotations (the one on the right
			is applied first)"])

XX(FR_DES,	NULL,	["The following operations return a frame value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	FRAME(r,v)	constructs frame of orientation r at position v
	CONSTRUCT(v,v,v)	makes a frame: first vector gives the position,
				second a point on the x-axis,
				third is a point in the xy-plane
	f + v		translation of a frame
	f - v		translation of a frame
	t * f		transformation of a frame
	f * f		transformation of a frame - shorthand for (station → f) * f"])

XX(TR_DES,	NULL,	["The following operations return a frame value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	TRANS(r,v)	constructs trans which will cause a rotation of r
			followed by a translation of v
	f → f		transformation which maps from the first frame
			to the second
	t * t		composition of two transes (the one on the right is
			applied first)
	INV(t)		take the inverse of t"])

XX(EXPRESSIONS,	"EXP",	"valid expressions")
YY(EXP_DES_X)
YY(EXP_SYN_X)
YY(EXP_PRI_X)

XX(EXP_DES,	"OPS",	"types of expressions")
YY(EXPRESSIONS_DES_X)
XX(EXP_SYN,	"BNF",	"bnf definition of expressions")
YY(EXPRESSIONS_SYNTAX_X)
XX(EXP_PRI,	"PRI",	"priority of operators")
YY(EXPRESSIONS_PRIORITY_X)

XX(EXPRESSIONS_DES, NULL,["The following are valid expressions:
	S=scalar, V=vector,R=rot,T=trans,F=frame

	RESULT	OPERATION

	S:	S+S,S-S,S*S,S/S,S↑S,LOG(S),EXP(S),INT(S),S MAX S,S MIN S,
		SIN(S),COS(S),TAN(S),ASIN(S),ACOS(S),ATAN2(S,S),
		V.V
	V:	V+V,V-V,V*V,V*S,V/S,(S,S,S),VECTOR(S,S,S)
		POS(F),POS(T)
	R:	ROT(V,S),ORIENT(F)
	F:	FRAME(R,V)
	T:	TRANS(R,V),(R,V)"])

XX(EXPRESSIONS_SYNTAX,NULL,["The following is the recursive definition of
	expressions in bnf form:

	<expression>	::=	<befact>{{OR|XOR <befact>}}
	<befact>	::=	<bterm>{{AND <bterm>}}
	<bterm>		::=	<arith_exp>| <arith_exp> <rel> <arith_exp>
	<arith_exp>	::=	{+|-} <term> {{+|- <term>}}
	<term>		::=	<factor> {{*|/ <factor>}}
	<factor>	::=	<pfactor>{↑ <pfactor>}
	<pfactor>	::=	(<expression>) or |<expression>| or
				<constant> or <id> or ¬ <pfactor> or funct or
				funct(<expression>{{,<expression}})"])

XX(EXPRESSIONS_PRIORITY,NULL,["	The operators in AL generally follow
	normal precedence rules, i.e., functions are evaluated first,
	followed by exponentiations before multiplications or divisions,
	which in turn are performed before additions and subtractions.
	The order of operation can be changed by including parentheses
	at appropriate points.  In an expression where several operators
	of the same precedence occur at the same level, the operations
	are performed from left to right.

		functions, (), | |, NOT
		WRT → ↑
		* / . MAX MIN DIV MOD
		+ -
		= ≠ < > ≤ ≥
		∧
		∨ ⊗
		≡"])
XX(FILE,	"FILE",	"Gives the file management commands")
YY(PHOTO_X)
YY(WRITE_X)
YY(READ_X)
YY(LOAD_VARIABLES_X)
YY(DUMP_VARIABLES_X)
YY(SAVECOREIMAGE_X)

XX(PHOTO,	"PHOTO","Saves the terminal session")
YY(PHOTO_DES_X)
XX(WRITE,	"WRITE",["Saves AL declarations, macros, procedures and arrays"])
YY(WRITE_DES_X)
XX(READ,	"READ",	"Reads AL instructions from a disk file")
YY(READ_DES_X)
XX(LOAD_VARIABLES,"LOAD","Fast loads variables saved from a file")
YY(LOAD_VARIABLES_DES_X)
XX(DUMP_VARIABLES,"DUMP","Dumps variables into a file")
YY(DUMP_VARIABLES_DES_X)
XX(SAVECOREIMAGE, "SAVE","Saves the core image")
YY(SAVECOREIMAGE_DES_X)


XX(PHOTO_DES,	NULL,	["	When you run POINTY, your terminal session
	will be logged automatically into POINTY.PHT[PNT,HE].
	If you wish to record your session
	in another file as well, the command PHOTO <filename> will save
	the terminal input into <filename>.  Once PHOTO is called, it will
	keep on recording until you make another call to PHOTO in which case
	it will stop recording in the old file and start recording
	into the new file name.
		Recording can only be done into a file that is not being
	referenced by some other user or job, and the file is written out
	every 6 lines or so, so that if you accidentally kill your job
	or the system crashes (knock on wood!) you will have a record of
	your terminal session."])

XX(WRITE_DES,	NULL,	["	The write command permits the state of the world
	to be saved on a disk file. The syntax is as follows:

		WRITE ALL|<var_list> {INTO <filename>}

	The instruction will write the values of all the variables,
	arrays, macros or the selected ones into the relevant file.
	If the filename is not specified, it will be written into
	the last file into which AL declarations were written."])

XX(READ_DES,	NULL,	["	File input of AL commands can be done by means of
	the READ <filename> command.  The file will be read to completion unless
	<ESCAPE> I is typed.
		Note that defaults instructions will not work from file input,
	and that statements must be separated by semicolons."])

XX(LOAD_VARIABLES_DES,NULL,["	Fast loads variables and procedure and macro
	declarations from a file written out by the DUMP_VARIABLES command.
	The syntax is as follows:

		LOAD_VARIABLES <filename>

	This procedure can only be invoked at toplevel."])

XX(DUMP_VARIABLES_DES,NULL,["	Dumps variable values and procedure and macro
	declarations into a file in a form readable by the LOAD_VARIABLES
	command.  The syntax is as follows:

		DUMP_VARIABLES <filename>

	This command can only be invoked at top level."])

XX(SAVECOREIMAGE_DES,NULL,["	Saves the core image of the 10 and the 11.
	This command saves the entire state of the program in a dump file
	with extension .DMP.  The syntax is as follows:

		SAVECOREIMAGE <filename>

	This will save a huge file (about 150K currently) and may easily
	send you over your disk allocation, so be sparing in its use.
	This command can only be invoked at top level.

		After saving the core image, the program will continue
	executing.  If you want to get this state back at a later
	time, you can do so by doing the monitor command

		RU <filename>"])
XX(ESCAPE_I,	"ESC_I","ESCAPE I command")
YY(ESCAPE_I_DES_X)
XX(ESCAPE_I_DES,NULL,	["	Hitting the <ESC> key followed by an I will
	interrupt whatever the PDP-10 is doing and throw you back to the
	top level.  Any type ahead will be destroyed.  If a file is being
	read, the rest of the file will be ignored.
		This command is useful when there is some error in the
	input file which causes the generation of a large number of error
	message, and you want to get command back to top level.
		A second place this command is useful is when
	there is some problem on the 11 and the system seems to be wedged.
	In this case it is still possible to save the values of variables
	that the PDP-10 knows about and start over.
		Typing <esc> I may not work if it is done during
	initialization, since the interrupt is not enabled at the
	end of initialization."])
XX(STATEMENTS,	"STATE","classes of statements")
YY(ASSIGNMENT_X)
YY(MOTION_X)
YY(DECLARATION_X)
YY(CONTROL_X)
YY(OTHER_AL_X)
YY(NON_AL_X)

XX(ASSIGNMENT,	["←"],	"assignment statement")
YY(ASSIGNMENT_DES_X)

XX(ASSIGNMENT_DES,NULL,	["	The assignment statement is of the form

		<variable> ← <expression>
	or	component(<variable>) ← <expression>

	where component is XCOORD,YCOORD,ZCOORD,POS or ORIENT.
	The data types on both sides of the assignment statement must
	be the same for the assignment to work, except that trans
	expressions may be assigned to frames.

		In the first form, if <variable> has not been declared,
	POINTY will declare it to be the same data type as the expression
	on the right hand side."])

XX(MOTION,	"MOT",	"list of motion commands")
YY(OPEN_X)
YY(CLOSE_X)
YY(MOVE_X)
YY(CENTER_X)
YY(GATHER_X)
YY(GRAPH_X)

XX(OPEN,	"OPEN",	"opens the hand")
YY(OPEN_DES_X)
XX(CLOSE,	"CLOS",	"similar to OPEN")
YY(OPEN_DES_X)

XX(OPEN_DES,	NULL,	["	The OPEN/CLOSE command applied to
	a hand causes the hand opening to go to the desired value.
	The syntax is as follows:

		OPEN <hand> TO|BY <scalar_exp>
		CLOSE <hand> TO|BY <scalar_exp>

	permitting the use of an absolute or relative value.
	Note that OPEN bhand BY 1 is the same as CLOSE bhand BY -1."])

XX(MOVE,	"MOVE",	"moves the arm")
YY(MOVE_DES_X)
XX(MOVE_DES,	NULL,	["	The MOVE command specifies the motion of
	the specified frame to the desired destination which may
	be in absolute or relative terms. The syntax is as follows:
		MOVE <frame> TO <frame1>,<frame2>,...,<framen>
			<condition monitors>
		where n≤9.  Currently the condition monitors available are
	the force and torque condition monitors whose syntax is as follows:
		ON FORCE(direction) <rel> <scalar_exp> {IN HAND|STATION}
			DO <statement>
		where <rel> is ≥ or < and direction is XHAT,YHAT, or ZHAT"])

XX(CENTER,	"CENTER","does a grasp")
YY(CENTER_DES_X)
XX(CENTER_DES,	NULL,	["	The CENTER command does adaptive grasping.
	The syntax is as follows:

		CENTER <arm>"])

XX(GATHER,	"GATH","gathers force and torque data")
YY(GATHER_DES_X)

XX(GATHER_DES,	NULL,	["	The GATHER command is used for collecting
	force data during the next motion.  You should put in as many
	components as you are interested in.  The syntax is as follows:

		GATHER(c1,c2,...,cn)

	where c1,c2,..cn are components and may be any of the terms
	FX,FY,FZ,MX,MY,MZ,T1,T2,T3,T4,T5,T6,TBL.  The first six represent
	forces and torques in the principal directions.  If TBL is specified,
	the quantities are in table coordinates, otherwise in hand coordinates.
	T1 thru T6 represent forces measured according to joints.

		The gather command sets up the preparatory commands
	for the next motion command, and after the next interaction
	with the runtime system which involves a motion, the data
	will be read back into POINTY and be available to be examined by
	the GRAPH command."])

XX(DECLARATION,	"DECL",	"declaration statement")
YY(DECLARATION_DES_X)

XX(DECLARATION_DES,NULL,["	Declarations may be made explicitly as
	in the case of AL, or implicitly by means of assignment statements.
	Explicit declarations may be made by means of the following
	syntactical construct:

		<data_type> <variable list>
	where <data_type> is one of SCALAR, VECTOR, ROT, TRANS, FRAME or
	EVENT.  <variable list> consists of a series of identifiers
	separated by commas.

		Arrays may be declared by including ARRAY after the data type,
	e.g.
		SCALAR ARRAY S[1:10,3:5]

	The indices may be constants or scalar expressions.  Scalar
	arrays will be initialized to 0, vector arrays to nilvect,
	rot arrays to nilrot, trans and frame arrays to niltrans.

		Macros are declared by means of the DEFINE statement,
	while procedures declarations are described in detail elsewhere."])

XX(CONTROL,	"CONT",	"list of control statements")
YY(IF_X)
YY(FOR_X)
YY(DO_X)
YY(WHILE_X)

XX(IF,		"IF",	"IF statement")
YY(IF_DES_X)
XX(IF_DES,	NULL,	["	The IF statement has the following syntax:

		IF <scalar exp> THEN <statement>
	or	IF <scalar exp> THEN <statement> ELSE <statement>

		The IF statement cannot be used as an expression."])
XX(FOR,		"FOR",	"FOR statement")
YY(FOR_DES_X)
XX(FOR_DES,	NULL,	["	The FOR statement has the following syntax:

		FOR <scalar> ← <scal exp> STEP <scal exp> UNTIL <scal exp>
			DO <statement>"])

XX(DO,		"DO",	"DO statement")
YY(DO_DES_X)
XX(DO_DES,	NULL,	["	The DO statement has the following syntax:

		DO <statement> UNTIL <condition>

	<statement> will be executed until <condition> becomes TRUE"])

XX(WHILE,	"WHILE","WHILE statement")
YY(WHILE_DES_X)
XX(WHILE_DES,	NULL,	["	The WHILE statement has the following syntax:

		WHILE <cond> DO <statement>

	<cond> is a scalar expression, and is checked.  If it is TRUE( non zero)
	<statement> is executed and the <cond> checked and <statement>
	executed and the sequence repeated until <cond> becomes FALSE(0)."])

XX(OTHER_AL,	"OTHERS","these are some of the other AL instructions")
YY(COMMENT_X)

XX(COMMENT,	"COMM",	"this describes use of COMMENTS")
YY(COMMENT_DES_X)

XX(COMMENT_DES,	NULL,["	There are two forms of comment statements.
	The first form is having the reserved word COMMENT followed
	by anything and ended by a semicolon.  The second
	form is enclosing the comment between open and close brace pairs
	e.g. {this is a comment} which may appear anywhere.  Note that
	the delimiters may be nested."])

XX(NON_AL,	"NON_AL","these non AL instructions facilitate interaction")
YY(EDIT_X)
YY(EEDIT_X)
YY(DELETE_X)
YY(DISPLAYS_X)
YY(GATHER_X)
YY(GRAPH_X)

XX(EDIT,	"EDIT",	"permits the changing of the value of simple variables")
YY(EDIT_DES_X)
XX(EDIT_DES,	NULL,	["	The EDIT command displays the values of
	variables to be displayed in the line editor
	and permits the user to change their values.  The syntax of the
	command is as follows:

			EDIT <variable name>

	where <variable name> is the name of the appropriate variable to be
	changed.  Currently only scalars, vectors, transes, rots or frames
	variables which are not arrays may be edited.  Macros may also be
	edited by means of this command."])

XX(EEDIT,	"EEDIT","writes the macro in a file and swaps to E")
YY(EEDIT_DES_X)
XX(EEDIT_DES,	NULL,	["	The EEDIT command takes a macro name
	as argument and writes it out into a disk file.  The core image
	is then saved, and the program swaps to E where the user is
	permitted to make changes to the macro body.  This is particularly
	useful when the macro body is a long one and many changes need
	to be made to it.  Minor changes may be made by means of the
	EDIT command.
		When you are satisfied with the macro, type <control>X RUN
	and you will get back to POINTY.  In the meantime please make sure
	not to change the state of the program on the PDP-11."])


XX(DELETE,	"DEL",	"deletes some or all variables")
YY(DELETE_DES_X)

XX(DELETE_DES,	NULL,	["	The DELETE command deletes all the user
	defined variables or some of them.  The syntax is as follows:

			DELETE ALL
			DELETE <variable list>

		In the first form, all user declared variables are
	deleted after asking for confirmation. In the second form
	POINTY will complain if some of the variables in the list are
	non existent.  In the second form, frame arrays may not be
	deleted.  Also, individual elements of an array may not
	be deleted.

		A more liberal form of the instruction is performed
	if DELETE is replaced by QDELETE.  In the first form, confirmation
	is not asked for, while in the second form, POINTY does not
	complain if the name in the variable list is non existent"])

XX(GRAPH,"GRAPH","explains the GRAPH command")
YY(GRAPH_DES_X)

XX(GRAPH_DES,	NULL,	["	The syntax of the graph command is simply
	GRAPH.  This command gets you into the module which helps to
	plot and save force data on a disk file or display on a data disc.
	This command is valid only after a GATHER and move.  On exiting
	the GRAPH module, the data is destroyed in order to reclaim the
	space which the data occupies for some other purpose."])
XX(ERROR,	"ERROR", "talks about how to handle errors")
YY(NO_ARM_X)
YY(PARSE_X)

XX(NO_ARM,	"NOARM", "what to do if there is no arm action")
YY(NO_ARM_DES_X)
XX(NO_ARM_DES,	NULL,	["	When the arm does not do what you expect
	it to do, namely move, there will probably be a message printed
	out at the VT05 console which may explain the error.
		One of the commonest forms of errors is that the power
	supply is off or one of the brake switches is off.  For the
	former, turn on the arm motor power by hitting the big red
	button on the underside of one of the short sides of the table.
		Sometimes the arm seems to move in weird fashions.
	When this happens, it may be that the arm is not properly
	initialised.  In this case, just reload and start the system
	again.
		There are two forms of recovery.  RETRY<alt>G at the
	VT05 will try to repeat the motion, while <alt>P will go on
	with the next instruction"])
XX(PARSE,	"PARSE", "explanation of error messages")
YY(PARSE_DES_X)
XX(PARSE_DES,	NULL,	["	POINTY is based on the assumption
	that it will be used interactively, and any errors encountered
	during parsing a statement results in abandoning any further
	processing and giving control back to the user.
		This may cause grief if there are move commands
	and errors occur in a disk file instead of in the terminal
	input mode.
		It also means that if you are trying to write
	a long program interactively you better not make any typing
	mistakes, or you will have to start over.
		It is much easier to build up programs as macros
	and to edit the macros if they do not behave as you think they
	should"])
XX(SYNTAX,	"SYNTAX","syntax of statements")
YY(FILE_SYN_X,	"FILSYN","syntax of file management commands")
YY(DISPLAY_SYN_X,"DISSYN","syntax of display commands")
YY(DECL_SYN_X,	"DECL",	"syntax of declaration commands")

XX(FILE_SYN,	NULL,	["	WRITE ALL INTO <filename>
	WRITE <variable list> INTO <filename>
	WRITE INTO <filename>
	READ <filename>
	QREAD <filename>
	LOAD_VARIABLES <filename>
	DUMP_VARIABLES <filename>
	SAVECOREIMAGE <filename>"])

XX(DISPLAY_SYN,	NULL,	["	REDISPLAY
	NODISPLAY
	DISPLAY <SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT>
	SHOW <variable list>
	VT05_ON
	VT05_OFF"])

XX(DECL_SYN,	NULL,	["	SCALAR s1,s2,s3,.....
	VECTOR v1,v2,v3,...
	ROT r1,r2,r3,...
	TRANS t1,t2,t3,...
	FRAME f1,f2,f3,...
	EVENT e1,e2,e3,...
	<SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT> ARRAY a[l1:u1,l2:u2,...ln:un]"])

XX(DONE,	"DONE",	"quits help mode")
];